/*
 * @lc app=leetcode.cn id=64 lang=cpp
 * @lcpr version=30204
 *
 * [64] 最小路径和
 */

// @lcpr-template-start
using namespace std;
#include <algorithm>
#include <array>
#include <bitset>
#include <climits>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// @lcpr-template-end
// @lc code=start
class Solution
{
public:
    // vector<vector<int>> memo;
    int minPathSum(vector<vector<int>> &grid)
    {
        // 方法一：记忆化搜索
        int m = grid.size();
        int n = grid[0].size();
        // memo.resize(m, vector<int>(n, INT_MAX));

        // return DFS(grid, m - 1, n - 1);

        // 方法二：动态规划
        vector<vector<int>> dp(m, vector<int>(n, INT_MAX));
        dp[0][0] = grid[0][0];
        // 初始化第一行
        for (int j = 1; j < n; ++j)
        {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }

        // 初始化第一列
        for (int i = 1; i < m; ++i)
        {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }

        for (int i = 1; i < m; ++i)
        {
            for (int j = 1; j < n; ++j)
            {
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }

private:
    // int DFS(vector<vector<int>> &grid, int x, int y)
    // {
    //     if (x < 0 || y < 0)
    //         return INT_MAX;
    //     if (x == 0 && y == 0)
    //         return grid[x][y];

    //     if (memo[x][y] != INT_MAX)
    //         return memo[x][y];

    //     return memo[x][y] = min(DFS(grid, x - 1, y), DFS(grid, x, y - 1)) + grid[x][y];
    // }
};
// @lc code=end

/*
// @lcpr case=start
// [[1,3,1],[1,5,1],[4,2,1]]\n
// @lcpr case=end

// @lcpr case=start
// [[1,2,3],[4,5,6]]\n
// @lcpr case=end

 */
